-/* GDK - The GIMP Drawing Kit\r
- * Copyright (C) 2009 Carlos Garnacho <carlosg@gnome.org>\r
- *\r
- * This library is free software; you can redistribute it and/or\r
- * modify it under the terms of the GNU Lesser General Public\r
- * License as published by the Free Software Foundation; either\r
- * version 2 of the License, or (at your option) any later version.\r
- *\r
- * This library is distributed in the hope that it will be useful,\r
- * but WITHOUT ANY WARRANTY; without even the implied warranty of\r
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\r
- * Lesser General Public License for more details.\r
- *\r
- * You should have received a copy of the GNU Lesser General Public\r
- * License along with this library. If not, see <http://www.gnu.org/licenses/>.\r
- */\r
-\r
-#include "config.h"\r
-\r
-#include <gdk/gdkwindow.h>\r
-\r
-#include <windowsx.h>\r
-#include <objbase.h>\r
-\r
-#include "gdkdisplayprivate.h"\r
-#include "gdkdevice-virtual.h"\r
-#include "gdkwin32.h"\r
-\r
-static gboolean gdk_device_virtual_get_history (GdkDevice *device,\r
- GdkWindow *window,\r
- guint32 start,\r
- guint32 stop,\r
- GdkTimeCoord ***events,\r
- gint *n_events);\r
-static void gdk_device_virtual_get_state (GdkDevice *device,\r
- GdkWindow *window,\r
- gdouble *axes,\r
- GdkModifierType *mask);\r
-static void gdk_device_virtual_set_window_cursor (GdkDevice *device,\r
- GdkWindow *window,\r
- GdkCursor *cursor);\r
-static void gdk_device_virtual_warp (GdkDevice *device,\r
- GdkScreen *screen,\r
+/* GDK - The GIMP Drawing Kit
+ * Copyright (C) 2009 Carlos Garnacho <carlosg@gnome.org>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+
+#include <gdk/gdkwindow.h>
+
+#include <windowsx.h>
+#include <objbase.h>
+
+#include "gdkdisplayprivate.h"
+#include "gdkdevice-virtual.h"
+#include "gdkwin32.h"
+
+static gboolean gdk_device_virtual_get_history (GdkDevice *device,
+ GdkWindow *window,
+ guint32 start,
+ guint32 stop,
+ GdkTimeCoord ***events,
+ gint *n_events);
+static void gdk_device_virtual_get_state (GdkDevice *device,
+ GdkWindow *window,
+ gdouble *axes,
+ GdkModifierType *mask);
+static void gdk_device_virtual_set_window_cursor (GdkDevice *device,
+ GdkWindow *window,
+ GdkCursor *cursor);
+static void gdk_device_virtual_warp (GdkDevice *device,
+ GdkScreen *screen,
gdouble x,
gdouble y);
-static void gdk_device_virtual_query_state (GdkDevice *device,\r
- GdkWindow *window,\r
- GdkWindow **root_window,\r
- GdkWindow **child_window,\r
- gdouble *root_x,\r
- gdouble *root_y,\r
- gdouble *win_x,\r
- gdouble *win_y,\r
- GdkModifierType *mask);\r
-static GdkGrabStatus gdk_device_virtual_grab (GdkDevice *device,\r
- GdkWindow *window,\r
- gboolean owner_events,\r
- GdkEventMask event_mask,\r
- GdkWindow *confine_to,\r
- GdkCursor *cursor,\r
- guint32 time_);\r
-static void gdk_device_virtual_ungrab (GdkDevice *device,\r
- guint32 time_);\r
-static GdkWindow * gdk_device_virtual_window_at_position (GdkDevice *device,\r
- gdouble *win_x,\r
- gdouble *win_y,\r
- GdkModifierType *mask,\r
- gboolean get_toplevel);\r
-static void gdk_device_virtual_select_window_events (GdkDevice *device,\r
- GdkWindow *window,\r
- GdkEventMask event_mask);\r
-\r
-\r
-G_DEFINE_TYPE (GdkDeviceVirtual, gdk_device_virtual, GDK_TYPE_DEVICE)\r
-\r
-static void\r
-gdk_device_virtual_class_init (GdkDeviceVirtualClass *klass)\r
-{\r
- GdkDeviceClass *device_class = GDK_DEVICE_CLASS (klass);\r
-\r
- device_class->get_history = gdk_device_virtual_get_history;\r
- device_class->get_state = gdk_device_virtual_get_state;\r
- device_class->set_window_cursor = gdk_device_virtual_set_window_cursor;\r
- device_class->warp = gdk_device_virtual_warp;\r
- device_class->query_state = gdk_device_virtual_query_state;\r
- device_class->grab = gdk_device_virtual_grab;\r
- device_class->ungrab = gdk_device_virtual_ungrab;\r
- device_class->window_at_position = gdk_device_virtual_window_at_position;\r
- device_class->select_window_events = gdk_device_virtual_select_window_events;\r
-}\r
-\r
-static void\r
-gdk_device_virtual_init (GdkDeviceVirtual *device_virtual)\r
-{\r
- GdkDevice *device;\r
-\r
- device = GDK_DEVICE (device_virtual);\r
-\r
-}\r
-\r
-void\r
-_gdk_device_virtual_set_active (GdkDevice *device,\r
- GdkDevice *new_active)\r
-{\r
- GdkDeviceVirtual *virtual = GDK_DEVICE_VIRTUAL (device);\r
- int n_axes, i;\r
- GdkAtom label_atom;\r
- GdkAxisUse use;\r
- gdouble min_value, max_value, resolution;\r
-\r
- if (virtual->active_device == new_active)\r
- return;\r
-\r
- virtual->active_device = new_active;\r
- \r
- if (gdk_device_get_source (device) != GDK_SOURCE_KEYBOARD)\r
- {\r
- _gdk_device_reset_axes (device);\r
- n_axes = gdk_device_get_n_axes (new_active);\r
- for (i = 0; i < n_axes; i++)\r
- {\r
- _gdk_device_get_axis_info (new_active, i,\r
- &label_atom, &use, \r
- &min_value, &max_value, &resolution);\r
- _gdk_device_add_axis (device,\r
- label_atom, use, \r
- min_value, max_value, resolution);\r
- }\r
- }\r
-\r
- g_signal_emit_by_name (G_OBJECT (device), "changed");\r
-}\r
-\r
-static gboolean\r
-gdk_device_virtual_get_history (GdkDevice *device,\r
- GdkWindow *window,\r
- guint32 start,\r
- guint32 stop,\r
- GdkTimeCoord ***events,\r
- gint *n_events)\r
-{\r
- /* History is only per slave device */\r
- return FALSE;\r
-}\r
-\r
-static void\r
-gdk_device_virtual_get_state (GdkDevice *device,\r
- GdkWindow *window,\r
- gdouble *axes,\r
- GdkModifierType *mask)\r
-{\r
- GdkDeviceVirtual *virtual = GDK_DEVICE_VIRTUAL (device);\r
- GdkDevice *active = virtual->active_device;\r
-\r
- GDK_DEVICE_GET_CLASS (active)->get_state (active,\r
- window, axes, mask);\r
-}\r
-\r
-static void\r
-gdk_device_virtual_set_window_cursor (GdkDevice *device,\r
- GdkWindow *window,\r
- GdkCursor *cursor)\r
-{\r
- GdkWin32Cursor *cursor_private;\r
- GdkWindow *parent_window;\r
- GdkWindowImplWin32 *impl;\r
- HCURSOR hcursor;\r
- HCURSOR hprevcursor;\r
-\r
- impl = GDK_WINDOW_IMPL_WIN32 (window->impl);\r
- cursor_private = (GdkWin32Cursor*) cursor;\r
-\r
- hprevcursor = impl->hcursor;\r
-\r
- if (!cursor)\r
- hcursor = NULL;\r
- else\r
- hcursor = cursor_private->hcursor;\r
-\r
- if (hcursor != NULL)\r
- {\r
- /* If the pointer is over our window, set new cursor */\r
+static void gdk_device_virtual_query_state (GdkDevice *device,
+ GdkWindow *window,
+ GdkWindow **root_window,
+ GdkWindow **child_window,
+ gdouble *root_x,
+ gdouble *root_y,
+ gdouble *win_x,
+ gdouble *win_y,
+ GdkModifierType *mask);
+static GdkGrabStatus gdk_device_virtual_grab (GdkDevice *device,
+ GdkWindow *window,
+ gboolean owner_events,
+ GdkEventMask event_mask,
+ GdkWindow *confine_to,
+ GdkCursor *cursor,
+ guint32 time_);
+static void gdk_device_virtual_ungrab (GdkDevice *device,
+ guint32 time_);
+static GdkWindow * gdk_device_virtual_window_at_position (GdkDevice *device,
+ gdouble *win_x,
+ gdouble *win_y,
+ GdkModifierType *mask,
+ gboolean get_toplevel);
+static void gdk_device_virtual_select_window_events (GdkDevice *device,
+ GdkWindow *window,
+ GdkEventMask event_mask);
+
+
+G_DEFINE_TYPE (GdkDeviceVirtual, gdk_device_virtual, GDK_TYPE_DEVICE)
+
+static void
+gdk_device_virtual_class_init (GdkDeviceVirtualClass *klass)
+{
+ GdkDeviceClass *device_class = GDK_DEVICE_CLASS (klass);
+
+ device_class->get_history = gdk_device_virtual_get_history;
+ device_class->get_state = gdk_device_virtual_get_state;
+ device_class->set_window_cursor = gdk_device_virtual_set_window_cursor;
+ device_class->warp = gdk_device_virtual_warp;
+ device_class->query_state = gdk_device_virtual_query_state;
+ device_class->grab = gdk_device_virtual_grab;
+ device_class->ungrab = gdk_device_virtual_ungrab;
+ device_class->window_at_position = gdk_device_virtual_window_at_position;
+ device_class->select_window_events = gdk_device_virtual_select_window_events;
+}
+
+static void
+gdk_device_virtual_init (GdkDeviceVirtual *device_virtual)
+{
+ GdkDevice *device;
+
+ device = GDK_DEVICE (device_virtual);
+
+}
+
+void
+_gdk_device_virtual_set_active (GdkDevice *device,
+ GdkDevice *new_active)
+{
+ GdkDeviceVirtual *virtual = GDK_DEVICE_VIRTUAL (device);
+ int n_axes, i;
+ GdkAtom label_atom;
+ GdkAxisUse use;
+ gdouble min_value, max_value, resolution;
+
+ if (virtual->active_device == new_active)
+ return;
+
+ virtual->active_device = new_active;
+
+ if (gdk_device_get_source (device) != GDK_SOURCE_KEYBOARD)
+ {
+ _gdk_device_reset_axes (device);
+ n_axes = gdk_device_get_n_axes (new_active);
+ for (i = 0; i < n_axes; i++)
+ {
+ _gdk_device_get_axis_info (new_active, i,
+ &label_atom, &use,
+ &min_value, &max_value, &resolution);
+ _gdk_device_add_axis (device,
+ label_atom, use,
+ min_value, max_value, resolution);
+ }
+ }
+
+ g_signal_emit_by_name (G_OBJECT (device), "changed");
+}
+
+static gboolean
+gdk_device_virtual_get_history (GdkDevice *device,
+ GdkWindow *window,
+ guint32 start,
+ guint32 stop,
+ GdkTimeCoord ***events,
+ gint *n_events)
+{
+ /* History is only per slave device */
+ return FALSE;
+}
+
+static void
+gdk_device_virtual_get_state (GdkDevice *device,
+ GdkWindow *window,
+ gdouble *axes,
+ GdkModifierType *mask)
+{
+ GdkDeviceVirtual *virtual = GDK_DEVICE_VIRTUAL (device);
+ GdkDevice *active = virtual->active_device;
+
+ GDK_DEVICE_GET_CLASS (active)->get_state (active,
+ window, axes, mask);
+}
+
+static void
+gdk_device_virtual_set_window_cursor (GdkDevice *device,
+ GdkWindow *window,
+ GdkCursor *cursor)
+{
+ GdkWin32Cursor *cursor_private;
+ GdkWindow *parent_window;
+ GdkWindowImplWin32 *impl;
+ HCURSOR hcursor;
+ HCURSOR hprevcursor;
+
+ impl = GDK_WINDOW_IMPL_WIN32 (window->impl);
+ cursor_private = (GdkWin32Cursor*) cursor;
+
+ hprevcursor = impl->hcursor;
+
+ if (!cursor)
+ hcursor = NULL;
+ else
+ hcursor = cursor_private->hcursor;
+
+ if (hcursor != NULL)
+ {
+ /* If the pointer is over our window, set new cursor */
GdkWindow *curr_window = gdk_window_get_device_position (window, device, NULL, NULL, NULL);
-\r
- if (curr_window == window ||\r
- (curr_window && window == gdk_window_get_toplevel (curr_window)))\r
- SetCursor (hcursor);\r
- else\r
- {\r
- /* Climb up the tree and find whether our window is the\r
- * first ancestor that has cursor defined, and if so, set\r
- * new cursor.\r
- */\r
- while (curr_window && curr_window->impl &&\r
- !GDK_WINDOW_IMPL_WIN32 (curr_window->impl)->hcursor)\r
- {\r
- curr_window = curr_window->parent;\r
- if (curr_window == GDK_WINDOW (window))\r
- {\r
- SetCursor (hcursor);\r
- break;\r
- }\r
- }\r
- }\r
- }\r
-\r
- /* Unset the previous cursor: Need to make sure it's no longer in\r
- * use before we destroy it, in case we're not over our window but\r
- * the cursor is still set to our old one.\r
- */\r
- if (hprevcursor != NULL &&\r
- GetCursor () == hprevcursor)\r
- {\r
- /* Look for a suitable cursor to use instead */\r
- hcursor = NULL;\r
- parent_window = GDK_WINDOW (window)->parent;\r
-\r
- while (hcursor == NULL)\r
- {\r
- if (parent_window)\r
- {\r
- impl = GDK_WINDOW_IMPL_WIN32 (parent_window->impl);\r
- hcursor = impl->hcursor;\r
- parent_window = parent_window->parent;\r
- }\r
- else\r
- hcursor = LoadCursor (NULL, IDC_ARROW);\r
- }\r
-\r
- SetCursor (hcursor);\r
- }\r
-}\r
-\r
-static void\r
-gdk_device_virtual_warp (GdkDevice *device,\r
- GdkScreen *screen,\r
+
+ if (curr_window == window ||
+ (curr_window && window == gdk_window_get_toplevel (curr_window)))
+ SetCursor (hcursor);
+ else
+ {
+ /* Climb up the tree and find whether our window is the
+ * first ancestor that has cursor defined, and if so, set
+ * new cursor.
+ */
+ while (curr_window && curr_window->impl &&
+ !GDK_WINDOW_IMPL_WIN32 (curr_window->impl)->hcursor)
+ {
+ curr_window = curr_window->parent;
+ if (curr_window == GDK_WINDOW (window))
+ {
+ SetCursor (hcursor);
+ break;
+ }
+ }
+ }
+ }
+
+ /* Unset the previous cursor: Need to make sure it's no longer in
+ * use before we destroy it, in case we're not over our window but
+ * the cursor is still set to our old one.
+ */
+ if (hprevcursor != NULL &&
+ GetCursor () == hprevcursor)
+ {
+ /* Look for a suitable cursor to use instead */
+ hcursor = NULL;
+ parent_window = GDK_WINDOW (window)->parent;
+
+ while (hcursor == NULL)
+ {
+ if (parent_window)
+ {
+ impl = GDK_WINDOW_IMPL_WIN32 (parent_window->impl);
+ hcursor = impl->hcursor;
+ parent_window = parent_window->parent;
+ }
+ else
+ hcursor = LoadCursor (NULL, IDC_ARROW);
+ }
+
+ SetCursor (hcursor);
+ }
+}
+
+static void
+gdk_device_virtual_warp (GdkDevice *device,
+ GdkScreen *screen,
gdouble x,
gdouble y)
-{\r
- SetCursorPos (x - _gdk_offset_x, y - _gdk_offset_y);\r
-}\r
-\r
-static void\r
-gdk_device_virtual_query_state (GdkDevice *device,\r
- GdkWindow *window,\r
- GdkWindow **root_window,\r
- GdkWindow **child_window,\r
- gdouble *root_x,\r
- gdouble *root_y,\r
- gdouble *win_x,\r
- gdouble *win_y,\r
- GdkModifierType *mask)\r
-{\r
- GdkDeviceVirtual *virtual = GDK_DEVICE_VIRTUAL (device);\r
-\r
- _gdk_device_query_state (virtual->active_device,\r
- window, root_window, child_window,\r
- root_x, root_y,\r
- win_x, win_y,\r
- mask);\r
-}\r
-\r
-static GdkGrabStatus\r
-gdk_device_virtual_grab (GdkDevice *device,\r
- GdkWindow *window,\r
- gboolean owner_events,\r
- GdkEventMask event_mask,\r
- GdkWindow *confine_to,\r
- GdkCursor *cursor,\r
- guint32 time_)\r
-{\r
- GdkWindowImplWin32 *impl = GDK_WINDOW_IMPL_WIN32 (window->impl);\r
- HCURSOR hcursor;\r
- GdkWin32Cursor *cursor_private;\r
-\r
- cursor_private = (GdkWin32Cursor*) cursor;\r
-\r
- if (gdk_device_get_source (device) != GDK_SOURCE_KEYBOARD)\r
- {\r
- if (!cursor)\r
- hcursor = NULL;\r
- else if ((hcursor = CopyCursor (cursor_private->hcursor)) == NULL)\r
- WIN32_API_FAILED ("CopyCursor");\r
-\r
- if (_gdk_win32_grab_cursor != NULL)\r
- {\r
- if (GetCursor () == _gdk_win32_grab_cursor)\r
- SetCursor (NULL);\r
- DestroyCursor (_gdk_win32_grab_cursor);\r
- }\r
-\r
- _gdk_win32_grab_cursor = hcursor;\r
-\r
- if (_gdk_win32_grab_cursor != NULL)\r
- SetCursor (_gdk_win32_grab_cursor);\r
- else if (impl->hcursor != NULL)\r
- SetCursor (impl->hcursor);\r
- else\r
- SetCursor (LoadCursor (NULL, IDC_ARROW));\r
-\r
- SetCapture (GDK_WINDOW_HWND (window));\r
- }\r
-\r
- return GDK_GRAB_SUCCESS;\r
-}\r
-\r
-static void\r
-gdk_device_virtual_ungrab (GdkDevice *device,\r
- guint32 time_)\r
-{\r
- GdkDeviceGrabInfo *info;\r
- GdkDisplay *display;\r
-\r
- display = gdk_device_get_display (device);\r
- info = _gdk_display_get_last_device_grab (display, device);\r
-\r
- if (info)\r
- info->serial_end = 0;\r
-\r
- if (gdk_device_get_source (device) != GDK_SOURCE_KEYBOARD)\r
- {\r
- if (_gdk_win32_grab_cursor != NULL)\r
- {\r
- if (GetCursor () == _gdk_win32_grab_cursor)\r
- SetCursor (NULL);\r
- DestroyCursor (_gdk_win32_grab_cursor);\r
- }\r
- _gdk_win32_grab_cursor = NULL;\r
-\r
- ReleaseCapture ();\r
- }\r
-\r
+{
+ SetCursorPos (x - _gdk_offset_x, y - _gdk_offset_y);
+}
+
+static void
+gdk_device_virtual_query_state (GdkDevice *device,
+ GdkWindow *window,
+ GdkWindow **root_window,
+ GdkWindow **child_window,
+ gdouble *root_x,
+ gdouble *root_y,
+ gdouble *win_x,
+ gdouble *win_y,
+ GdkModifierType *mask)
+{
+ GdkDeviceVirtual *virtual = GDK_DEVICE_VIRTUAL (device);
+
+ _gdk_device_query_state (virtual->active_device,
+ window, root_window, child_window,
+ root_x, root_y,
+ win_x, win_y,
+ mask);
+}
+
+static GdkGrabStatus
+gdk_device_virtual_grab (GdkDevice *device,
+ GdkWindow *window,
+ gboolean owner_events,
+ GdkEventMask event_mask,
+ GdkWindow *confine_to,
+ GdkCursor *cursor,
+ guint32 time_)
+{
+ GdkWindowImplWin32 *impl = GDK_WINDOW_IMPL_WIN32 (window->impl);
+ HCURSOR hcursor;
+ GdkWin32Cursor *cursor_private;
+
+ cursor_private = (GdkWin32Cursor*) cursor;
+
+ if (gdk_device_get_source (device) != GDK_SOURCE_KEYBOARD)
+ {
+ if (!cursor)
+ hcursor = NULL;
+ else if ((hcursor = CopyCursor (cursor_private->hcursor)) == NULL)
+ WIN32_API_FAILED ("CopyCursor");
+
+ if (_gdk_win32_grab_cursor != NULL)
+ {
+ if (GetCursor () == _gdk_win32_grab_cursor)
+ SetCursor (NULL);
+ DestroyCursor (_gdk_win32_grab_cursor);
+ }
+
+ _gdk_win32_grab_cursor = hcursor;
+
+ if (_gdk_win32_grab_cursor != NULL)
+ SetCursor (_gdk_win32_grab_cursor);
+ else if (impl->hcursor != NULL)
+ SetCursor (impl->hcursor);
+ else
+ SetCursor (LoadCursor (NULL, IDC_ARROW));
+
+ SetCapture (GDK_WINDOW_HWND (window));
+ }
+
+ return GDK_GRAB_SUCCESS;
+}
+
+static void
+gdk_device_virtual_ungrab (GdkDevice *device,
+ guint32 time_)
+{
+ GdkDeviceGrabInfo *info;
+ GdkDisplay *display;
+
+ display = gdk_device_get_display (device);
+ info = _gdk_display_get_last_device_grab (display, device);
+
+ if (info)
+ info->serial_end = 0;
+
+ if (gdk_device_get_source (device) != GDK_SOURCE_KEYBOARD)
+ {
+ if (_gdk_win32_grab_cursor != NULL)
+ {
+ if (GetCursor () == _gdk_win32_grab_cursor)
+ SetCursor (NULL);
+ DestroyCursor (_gdk_win32_grab_cursor);
+ }
+ _gdk_win32_grab_cursor = NULL;
+
+ ReleaseCapture ();
+ }
+
_gdk_display_device_grab_update (display, device, device, 0);
-}\r
-\r
-static void\r
-screen_to_client (HWND hwnd, POINT screen_pt, POINT *client_pt)\r
-{\r
- *client_pt = screen_pt;\r
- ScreenToClient (hwnd, client_pt);\r
-}\r
-\r
-static GdkWindow *\r
-gdk_device_virtual_window_at_position (GdkDevice *device,\r
- gdouble *win_x,\r
- gdouble *win_y,\r
- GdkModifierType *mask,\r
- gboolean get_toplevel)\r
-{\r
- GdkWindow *window = NULL;\r
- POINT screen_pt, client_pt;\r
- HWND hwnd, hwndc;\r
- RECT rect;\r
-\r
- GetCursorPos (&screen_pt);\r
-\r
- if (get_toplevel)\r
- {\r
- /* Only consider visible children of the desktop to avoid the various\r
- * non-visible windows you often find on a running Windows box. These\r
- * might overlap our windows and cause our walk to fail. As we assume\r
- * WindowFromPoint() can find our windows, we follow similar logic\r
- * here, and ignore invisible and disabled windows.\r
- */\r
- hwnd = GetDesktopWindow ();\r
- do {\r
- window = gdk_win32_handle_table_lookup (hwnd);\r
-\r
- if (window != NULL &&\r
- GDK_WINDOW_TYPE (window) != GDK_WINDOW_ROOT &&\r
- GDK_WINDOW_TYPE (window) != GDK_WINDOW_FOREIGN)\r
- break;\r
-\r
- screen_to_client (hwnd, screen_pt, &client_pt);\r
- hwndc = ChildWindowFromPointEx (hwnd, client_pt, CWP_SKIPDISABLED |\r
- CWP_SKIPINVISIBLE);\r
-\r
- /* Verify that we're really inside the client area of the window */\r
- if (hwndc != hwnd)\r
- {\r
- GetClientRect (hwndc, &rect);\r
- screen_to_client (hwndc, screen_pt, &client_pt);\r
- if (!PtInRect (&rect, client_pt))\r
- hwndc = hwnd;\r
- }\r
-\r
- } while (hwndc != hwnd && (hwnd = hwndc, 1));\r
-\r
- }\r
- else\r
- {\r
- hwnd = WindowFromPoint (screen_pt);\r
-\r
- /* Verify that we're really inside the client area of the window */\r
- GetClientRect (hwnd, &rect);\r
- screen_to_client (hwnd, screen_pt, &client_pt);\r
- if (!PtInRect (&rect, client_pt))\r
- hwnd = NULL;\r
-\r
- /* If we didn't hit any window at that point, return the desktop */\r
- if (hwnd == NULL)\r
- {\r
- if (win_x)\r
- *win_x = screen_pt.x + _gdk_offset_x;\r
- if (win_y)\r
- *win_y = screen_pt.y + _gdk_offset_y;\r
- return _gdk_root;\r
- }\r
-\r
- window = gdk_win32_handle_table_lookup (hwnd);\r
- }\r
-\r
- if (window && (win_x || win_y))\r
- {\r
- if (win_x)\r
- *win_x = client_pt.x;\r
- if (win_y)\r
- *win_y = client_pt.y;\r
- }\r
-\r
- return window;\r
-}\r
-\r
-static void\r
-gdk_device_virtual_select_window_events (GdkDevice *device,\r
- GdkWindow *window,\r
- GdkEventMask event_mask)\r
-{\r
-}\r
+}
+
+static void
+screen_to_client (HWND hwnd, POINT screen_pt, POINT *client_pt)
+{
+ *client_pt = screen_pt;
+ ScreenToClient (hwnd, client_pt);
+}
+
+static GdkWindow *
+gdk_device_virtual_window_at_position (GdkDevice *device,
+ gdouble *win_x,
+ gdouble *win_y,
+ GdkModifierType *mask,
+ gboolean get_toplevel)
+{
+ GdkWindow *window = NULL;
+ POINT screen_pt, client_pt;
+ HWND hwnd, hwndc;
+ RECT rect;
+
+ GetCursorPos (&screen_pt);
+
+ if (get_toplevel)
+ {
+ /* Only consider visible children of the desktop to avoid the various
+ * non-visible windows you often find on a running Windows box. These
+ * might overlap our windows and cause our walk to fail. As we assume
+ * WindowFromPoint() can find our windows, we follow similar logic
+ * here, and ignore invisible and disabled windows.
+ */
+ hwnd = GetDesktopWindow ();
+ do {
+ window = gdk_win32_handle_table_lookup (hwnd);
+
+ if (window != NULL &&
+ GDK_WINDOW_TYPE (window) != GDK_WINDOW_ROOT &&
+ GDK_WINDOW_TYPE (window) != GDK_WINDOW_FOREIGN)
+ break;
+
+ screen_to_client (hwnd, screen_pt, &client_pt);
+ hwndc = ChildWindowFromPointEx (hwnd, client_pt, CWP_SKIPDISABLED |
+ CWP_SKIPINVISIBLE);
+
+ /* Verify that we're really inside the client area of the window */
+ if (hwndc != hwnd)
+ {
+ GetClientRect (hwndc, &rect);
+ screen_to_client (hwndc, screen_pt, &client_pt);
+ if (!PtInRect (&rect, client_pt))
+ hwndc = hwnd;
+ }
+
+ } while (hwndc != hwnd && (hwnd = hwndc, 1));
+
+ }
+ else
+ {
+ hwnd = WindowFromPoint (screen_pt);
+
+ /* Verify that we're really inside the client area of the window */
+ GetClientRect (hwnd, &rect);
+ screen_to_client (hwnd, screen_pt, &client_pt);
+ if (!PtInRect (&rect, client_pt))
+ hwnd = NULL;
+
+ /* If we didn't hit any window at that point, return the desktop */
+ if (hwnd == NULL)
+ {
+ if (win_x)
+ *win_x = screen_pt.x + _gdk_offset_x;
+ if (win_y)
+ *win_y = screen_pt.y + _gdk_offset_y;
+ return _gdk_root;
+ }
+
+ window = gdk_win32_handle_table_lookup (hwnd);
+ }
+
+ if (window && (win_x || win_y))
+ {
+ if (win_x)
+ *win_x = client_pt.x;
+ if (win_y)
+ *win_y = client_pt.y;
+ }
+
+ return window;
+}
+
+static void
+gdk_device_virtual_select_window_events (GdkDevice *device,
+ GdkWindow *window,
+ GdkEventMask event_mask)
+{
+}
projects / gtk4.git / commitdiff